# 输入日期， 判断这一天是这一年的第几天？
# import datetime
# def dayofyear():
#     year = input("请输入年份： ")
#     month = input("请输入月份： ")
#     day = input("请输入天： ")
#     date1 = datetime.date(year=int(year), month=int(month), day=int(day))
#     date2 = datetime.date(year=int(year), month=1, day=1)
#     print((date1 - date2).days + 1)
#     return (date1 - date2).days + 1
# dayofyear()

# 打乱一个排好序的对象
# 打乱一个排好序的对象为random.shuffle(列表)
# import random
#
# alist = [1, 2, 3, 4, 5]
# random.shuffle(alist)
# print(alist)

# 现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?
# 用sorted对字典对象值的排序，sorted(d.items(), key=lambda x:x[1])
from functools import reduce

d = {'a': 24, 'g': 52, 'i': 12, 'k': 33}
print(sorted(d.items(), key=lambda x: x[1]))

# 字符串反转  a[::-1]
a = 'adssadasdasdas'
print(a[::-1])

# 将字符串 "k:1 |k1:2|k2:3|k3:4"，处理成字典 {k:1,k1:2,...}
str1 = "k:1|k1:2|k2:3|k3:4"


def str2dict(str1):
    dict1 = {}
    for iterms in str1.split('|'):
        key, value = iterms.split(':')
        dict1[key] = value
    return dict1


# 字典推导式
d = {k: int(v) for t in str1.split("|") for k, v in (t.split(":"),)}

# Python中如何动态获取和设置对象的属性？

# hasattr() 函数用于判断对象是否包含对应的属性。
# if hasattr(Parent, 'x'):
#     # getattr()函数用于返回一个对象属性值。
#   print(getattr(Parent, 'x'))
# # setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
#   setattr(Parent, 'x',3)
# print(getattr(Parent,'x'))

# python的内存管理机制及调优手段
# 内存管理机制：引用计数，垃圾回收、内存池
# 引用技术：引用技术是一种非常搞笑的内存管理手段，当一个python对象被引用时其引用技术增加1，当其不再被一个变量引用时则计数减1,当引用计数等于0时对象被删除。弱引用不会增加引用计数

# 垃圾回收
# 引用计数
print(filter(lambda x: x % 2 == 0, range(10)))
# 输出的数组
print(list(filter(lambda x: x % 2 == 0, range(100))))
print(list(filter(lambda x: x % 2 == 0, range(10))))


# 输出的数值


# 登录的装饰器
def new_func(func):
    def wrappedfun(username, password):
        if username == 'root' and password == '123456':
            print('通过认证')
            print('开始执行附加功能')
            return func()
        else:
            print('用户名或密码错误')
            return

    return wrappedfun


@new_func
def origin():
    print('开始执行函数')


origin('root', '6666')

# 为什么函数名字可以当做参数用?
# python中一切皆为对像，函数名是在内存中的空间，也是一个对象


# 交换两个变量的值？
a = 10
b = 20
a, b = b, a
print(a)
print(b)

# map函数和reduce函数？
map(lambda x: x * x, [1, 2, 3, 4])  # 使用lambda
print(list(map(lambda x: x * x, [1, 2, 3, 4])))  # 相当于 1*1  2*2  3*3  4*4
print(reduce(lambda x, y: x * y, [1, 2, 3, 4]))  # 相当于 ((1 * 2) * 3) * 4


# post和get请求
# get是从服务器上获取数据，post是向服务器传送数据
# 在客户端，Get方式在通过URL提交数据，数据在URL中可以 看到，POST方式，数据放置在HTML--HEADER内提交
# 对于GET方式，服务器端用Request.QueryString获取变量的值，对于POST方式，服务端用Request.Form获取提交的数据


# 153条
# django的中间件的使用？
# django在中间预制了6个方法，这六个方法的区别在于不同的阶段执行，对输入或输出进行干预

def __init__():
    pass


def process_request(request):
    pass


def process_view(request, view_func, view_args, view_kwargs):
    pass


# 1.uWSGI是一个Web服务器，它实现了WSGI协议、uwsgi、http等协议
# python中的三大框架各自的应用场景


# redis宕机怎样解决呢
# 宕机：服务器停止服务
# 如果只有一台redis, 肯定会造成数据丢失，无法挽留。
# 多态redis或者redis集群，宕机则需要分为在主从模式下区分来看
# slave从redis宕机，配置主从复制的时候才配置从的redis，从的会从主的redis中读取主的redis的操作，日志1，在redis中从库重新启动后会自动加入到主从架构中，自动完成同步数据;
# 如果从数据库实现了持久化，此时千万不要立马重启服务，否则可能会造成数据丢失，正确的操作如下：在slave数据上执行SLAVEOF ON ONE,来断开主从关系并把slave升级为主库，此时重新启动主数据库，执行SLAVEOF，把它设置为从库，连接到主的redis上面做主从复制，自动备份数据。
# 可以使用redis提供的哨兵机制来简化上面的操作。简单的方法:redis的哨兵 (sentinel)的功能
# redis和mecached的区别，以及使用场景

# .Redis集群方案该怎么做?都有哪些方案?
# 基本和twemproxy一致的效果

# 菲薄那齐数列
# nterms = int(input("你需要几项？"))
# n1 = 0
# n2 = 1
# count = 0
# # 判断输入的值是否合法
# if nterms <= 0:
#     print("请输入一个正整数。 ")
# elif nterms == 1:
#     print("菲薄哪些数列: ")
#     print(n1)
# else:
#     print("斐波那契数列：")
#     print(n1, ",", n2, end=" , ")
#     while count < nterms:
#         nth = n1 + n2
#         print(nth, end=" , ")
#         # 更新值
#         n1 = n2
#         n2 = nth
#         count += 1

def fibonacci(n):
    if n == 0 or n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)


print(fibonacci(6))

# 矩阵

import numpy as np


def fibonacci(n):
    return (np.matrix([[0, 1], [1, 1]]) ** n)[1, 1]


aaa = fibonacci(10)
print(aaa)


# 一只青蛙要跳上n层高的台阶，一次能跳一级，也可以跳两级，请问这只青蛙有多少种跳上这个n层台阶的方法？
# 设最后一次跳一级台阶（f(n-1)），第二次跳两级台阶(f(n-2)) ----推出 f(n)=f(n-1)+f(n-2)
# 显然 发f(1) = 1,,f(2) = 2

class Solution:
    def climbStairs(self, n):
        if n == 1:
            return 1
        elif n == 2:
            return 2
        else:
            return self.climbStairs(n - 1) + self.climbStairs(n - 2)

# 统计
# 字典方法
words = ['my', 'skills', 'are', 'poor', 'I', 'am', 'poor', 'I','need', 'skills', 'more', 'my', 'ability', 'are','so', 'poor']
dict1 = {}
for i in words:
    if i not in dict1.keys():
        dict1[1] = words.count(i)
print(dict1)

# 问题与优化方式
# 1、django并发性能差 使用uWSGI Master+worker配合gevent携程支持高并发
# 2、Redis连接数过多，使用redis-py自带的连接池来实现连接复用
# 3、MySQL连接数过多 使用Djorm-ext-pool连接池复用连接
# 4、Celery配置gevent支持并发任务

#可变： 列表 集合 字典
#不可变： 整形 字符串 元祖

# 列表推导式，装饰器，迭代器
# 手写一个装饰器
# import datetime
# class TimeException(Exception):
#     def __int__(self, excception_info):
#         super().__init__()
#         self.info = excception_info
#     def __str__(self):
#         return self.info
#
# def timecheck(func):
#     def wrapper(*args, **kwargs):
#         if datetime.datetime.now().year == 2019:
#             func(*args, **kwargs)
#         else:
#             raise TimeException("函数已经超时")
#     return wrapper
#
# @timecheck
# def test(name):
#     print("Hello {}, 2019 Happy".format(name))
#
# if __name__ == "__main__":
#     test("backbp")

#值传递和引用传递
# 不可变参数用值传递
# 可变参数用引用传递
globals() #定义全局变量


# python内置的filter()方法来过滤？
print(list(filter(lambda x :x%2==0,range(10))))


# grant all privileges on *.* to 'root'@'ip' identified by '密码';